import com.sun.deploy.panel.ExceptionListDialog;

import java.util.*;

/**
 * Created whit IntelliJ IDEA.
 * Description：
 * User：ZHONGCHEN
 * Date:2022-03-31
 * Time:22:01
 */
public class TestDemo {
    //收件人列表
    public static void main1(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = Integer.parseInt(scanner.nextLine());
            String ans = "";
            for (int i = n; i > 0; i--) {
                String s = scanner.nextLine();
                //字符中含有 ","或者空格 就给该字符添加上"字符"
                if (s.contains(",") || s.contains(" ")) {
                    s = "\"" + s + "\"";
                }
                if (i != 1) {//字符与字符之间用逗号空格隔开
                    ans = ans + s + ", ";
                } else {//最后一个字符后不用加逗号空格
                    ans = ans + s;
                }
            }
            System.out.println(ans);
        }
    }

    public static void main2(String[] args) {
        int[] arr = {2, 1, 1, 4, 8, 8};
        System.out.println(canReorderDoubled(arr));

    }

    /*954. 二倍数对数组
     * 给定一个长度为偶数的整数数组 arr，只有对 arr 进行重组后可以满足
     * “对于每个 0 <= i < len(arr) / 2，都有 arr[2 * i + 1] = 2 * arr[2 * i]” 时，
     * 返回 true；否则，返回 false。
     */
    //想想数组中最大的数或者最小的数，会发现它们要配对的数是固定的，很容易检查。
    //我们将数组压缩为哈希表计数，并按序遍历键，依次抛去配对数，不能配对直接返回false
    public static boolean canReorderDoubled(int[] arr) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : arr) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        //获取Map对象的所有键名
        List<Integer> list = new ArrayList<>(map.keySet());
        //将list从小到大排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        for (int key : list) {
            if (key > 0) {
                if (map.getOrDefault(key * 2, 0) < map.get(key)) {
                    return false;
                }
                if (map.get(key) > 0) {
                    map.put(key * 2, map.get(key * 2) - map.get(key));
                }
            } else if (key == 0) {
                if (map.get(key) % 2 != 0) {
                    return false;
                }
            } else {
                //当key为负数时;因为输入的都是整数,所以要是出现key%2 != 0 则认为该数字在数组中找不到二倍数
                if (map.get(key) > 0 && ((key % 2 != 0) || map.getOrDefault(key / 2, 0) < map.get(key))) {
                    return false;
                }
                if (map.get(key) > 0) {
                    map.put(key / 2, map.get(key / 2) - map.get(key));
                }
            }
        }
        return true;
    }

    //年会抽奖
    /*
    今年公司年会的奖品特别给力，但获奖的规矩却很奇葩：
    1. 首先，所有人员都将一张写有自己名字的字条放入抽奖箱中；
    2. 待所有字条加入完毕，每人从箱中取一个字条；
    3. 如果抽到的字条上写的就是自己的名字，那么“恭喜你，中奖了！”
    现在告诉你参加晚会的人数，请你计算有多少概率会出现无人获奖？*/
    //解这道题，我们需要明白什么时候才算做都不获奖？全部都不获奖的概率如何计算？
    //对于什么时候才算做都不获奖，当然是所有人都拿到了别人的名字，没有拿到自己的名字。
    //全部都不获奖的概率必定是由 n个人都拿错的情况种数 除 n个人拿出的所有排列情况数。
    //n个人拿出的所有排列情况数显然是n的阶乘。
    //假设a的名字没有被a拿到，其他n - 1个人都有可能拿到，即有n - 1种情况。假设b拿到了a的名字，那么对于b的名字有两种情况，
    //第一种是b的名字被a拿到了，也就是a、b互相拿到了对方的名字，那么对于其他n - 2个人互相拿错又是一个子问题f(n - 2).
    //第二种是b的名字没有被a拿到，则剩下的问题是子问题f(n - 1).
    //最终得出公式n人都不获奖的概率h(n) = (n - 1) * (f(n - 1) + f(n - 2)) / (n!).
    static long[] ans = new long[21];

    public static void main3(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ans[0] = 0;
        ans[1] = 0;
        ans[2] = 1;
        lottery();
        while (scanner.hasNext()) {
            int num = scanner.nextInt();
            //求阶乘
            double sum1 = factorial(num);
            double sum2 = ans[num];
            double result = (sum2 / sum1) * 100;
            System.out.println(String.format("%.2f", result) + "%");
        }
    }

    private static double factorial(int num) {
        double ans = 1;
        while (num > 0) {
            ans *= num;
            num--;
        }
        return ans;
    }

    private static void lottery() {
        for (int i = 3; i < ans.length; i++) {
            //假设a的名字没有被a拿到，其他n - 1个人都有可能拿到，即有n - 1种情况----(i-1)
            // 第一种是b的名字被a拿到了，也就是a、b互相拿到了对方的名字，那么对于其他n - 2个人互相拿错又是一个子问题ans[i - 2].
            // 第二种是b的名字没有被a拿到，则剩下的问题是子问题ans[i - 1]
            ans[i] = (i - 1) * (ans[i - 1] + ans[i - 2]);
        }
    }
    //抄送列表
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            char[] chars = scanner.nextLine().toCharArray();
            Set<String> set = new HashSet<>();
            StringBuilder name = new StringBuilder();
            boolean flag = false;
            for (int i = 0; i < chars.length; i++) {
                char ch = chars[i];
                if (ch == '\"') {
                    //作为一个开关
                    flag = !flag;
                    continue;
                }
                if (ch == ',' && !flag) {
                    //遇到 ',' && !flag 则认为一个名字结束
                    set.add(name.toString());
                    //重置StringBuilder
                    name.setLength(0);
                    continue;
                }
                name.append(ch);
            }
            set.add(name.toString());
            String nameTwo = scanner.nextLine();
            System.out.println(!set.contains(nameTwo)?"Important!":"Ignore");
        }
    }
}
